package solutions.ferpa.ztest.intf;

import br.com.telescope.adsrt.dom.DomDate;
import br.com.telescope.adsrt.dom.DomDateTime;
import br.com.telescope.adsrt.dom.DomDouble;
import br.com.telescope.adsrt.dom.DomFlag;
import br.com.telescope.adsrt.dom.DomId;
import br.com.telescope.adsrt.dom.DomInteger;
import br.com.telescope.adsrt.dom.DomOption;
import br.com.telescope.adsrt.dom.DomText;
import br.com.telescope.adsrt.dom.DomUpper;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.adsrt.lib.AdsException;
import br.com.telescope.adsrt.lib.Form;
import br.com.telescope.sql.ModelQuery;
import br.com.telescope.t2.EntityBinding;
import br.com.telescope.t2.ModuleNavigator;
import br.com.telescope.t2.ServiceModel;
import br.com.telescope.t2.exception.ApplicationRuntimeException;
import br.com.telescope.t2.exception.Severity;
import br.com.telescope.t2.feature.AbstractFeature;
import br.com.telescope.t2.feature.DeleteFeature;
import br.com.telescope.t2.feature.InsertFeature;
import br.com.telescope.t2.feature.ListFeature;
import br.com.telescope.t2.feature.LookupFeature;
import br.com.telescope.t2.feature.QueryFeature;
import br.com.telescope.t2.feature.UpdateFeature;
import br.com.telescope.t2.feature.ViewFeature;
import br.com.telescope.util.ObjectUtil;
import solutions.ferpa.ztest.ent.*;
import solutions.ferpa.ztest.intf.*;

/**
 * Solicitações de ensaios.
 * <p>
 * Interface para manutenção de Solicitação de ensaio
 * <P>
 * Telescope origin: ZTEST.CAD_SOLICITACAO_ENSAIO
 * <P>
 * Base entity: ZTEST.SOLICITACAO_ENSAIO
 * <P>
 * @author TELESCOPE - Build task T2 Web Interface Generator
 * <P>
 * @version 0.1
 */
public class CadSolicitacaoEnsaio extends ServiceModel {
    
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    public static final String GLOBAL_NAME = "ZTEST.CAD_SOLICITACAO_ENSAIO";
    
    @Override
    public String globalName() {
        return GLOBAL_NAME;
    }
    
    {
        setTitle("Solicitações de ensaios");
    }
    
    protected EntSolicitacaoEnsaio base;
    protected EntModeloHidrometro mdlh;
    protected EntPlanoExecucao plex;
    protected EntVazaoPrefixoSerie vpfs;
    protected EntSolicitacaoEnsaio rec; // NEED_TJW1_COMPATIBILITY
    
    // Record items
    private DomId aSequenciaAutomatica;
    private DomOption aOrigemSolicitacao;
    private DomText aOrdemProducao;
    private DomText aCodigo;
    private DomOption aSituacao;
    private DomDateTime aDataHoraRegistro;
    private DomDate aDataEnsaio;
    private DomInteger aQuantidadeHidrometros;
    private DomInteger aQuantidadeHidrometrosAprovados;
    private DomInteger aQuantidadeHidrometrosExecucao;
    private DomInteger aQuantidadeHidrometrosPendentes;
    private DomInteger aQuantidadeHidrometrosReprovados;
    private DomFlag aReservaSequencias;
    private DomId aId;
    private DomId aModeloHidrometroId;
    private DomId aPlanoExecucaoId;
    private DomUpper aMdlhCodigo;
    private DomText aMdlhNome;
    private DomInteger aMdlhDiametroNominal;
    private DomUpper aPlexNome;
    private DomOption aPlexSituacao;
    private DomDouble aVpfsVazaoNominal;
    
    // Query items
    private DomDateTime qDataHoraRegistro;
    private DomUpper qPlexNome;
    private DomInteger qQuantidadeHidrometros;
    private DomText qCodigo;
    private DomDate qDataEnsaio;
    private DomUpper qMdlhCodigo;
    private DomOption qSituacao;
    private DomText qMdlhNome;
    private DomDouble qVpfsVazaoNominal;
    private DomId qSequenciaAutomatica;
    private DomOption qOrigemSolicitacao;
    
    @Override
    public String getBaseSql() {
        return "select BASE.*"
                + " , MDLH.CODIGO as MDLH_CODIGO"
                + " , MDLH.DESCRICAO as MDLH_NOME"
                + " , MDLH.DIAMETRO_NOMINAL as MDLH_DIAMETRO_NOMINAL"
                + " , PLEX.NOME as PLEX_NOME"
                + " , PLEX.SITUACAO as PLEX_SITUACAO"
                + " , VPFS.VAZAO_NOMINAL as VPFS_VAZAO_NOMINAL"
                + " , MDLH.ID as Z_MDLH_ID"
                + " , PLEX.ID as Z_PLEX_ID"
                + " , VPFS.ID as Z_VPFS_ID"
                + " from SOLICITACAO_ENSAIO BASE"
                + " join MODELO_HIDROMETRO MDLH on MDLH.ID = BASE.MODELO_HIDROMETRO_ID"
                + " join VAZAO_PREFIXO_SERIE VPFS on VPFS.ID = MDLH.VAZAO_PREFIXO_SERIE_ID"
                + " join PLANO_EXECUCAO PLEX on PLEX.ID = BASE.PLANO_EXECUCAO_ID";
    }
    
    @Override
    public void initAttributes() {
        
        aSequenciaAutomatica = new DomId();
        aSequenciaAutomatica.context(ctx).name("SEQUENCIA_AUTOMATICA").label("Sequência automática");
        
        aOrigemSolicitacao = new DomOption();
        aOrigemSolicitacao.context(ctx).name("ORIGEM_SOLICITACAO").label("Origem da solicitação").group(true);
        aOrigemSolicitacao.addOption("T", "Teste");
        aOrigemSolicitacao.addOption("O", "Ordem de produção");
        aOrigemSolicitacao.setDefaultValue("T");
        
        aOrdemProducao = new DomText();
        aOrdemProducao.context(ctx).name("ORDEM_PRODUCAO").label("Ordem de produção");
        
        aCodigo = new DomText();
        aCodigo.context(ctx).name("CODIGO").label("Código da solicitação");
        
        aSituacao = new DomOption();
        aSituacao.context(ctx).name("SITUACAO").label("Situação da solicitação").group(true);
        aSituacao.addOption("P", "Pendente");
        aSituacao.addOption("E", "Em execução");
        aSituacao.addOption("F", "Finalizado");
        aSituacao.setDefaultValue("P");
        
        aDataHoraRegistro = new DomDateTime();
        aDataHoraRegistro.context(ctx).name("DATA_HORA_REGISTRO").label("Data e hora do registro");
        aDataHoraRegistro.setDefaultValue("[SYSDATE]");
        
        aDataEnsaio = new DomDate();
        aDataEnsaio.context(ctx).name("DATA_ENSAIO").label("Data planejada para o ensaio");
        
        aQuantidadeHidrometros = new DomInteger();
        aQuantidadeHidrometros.context(ctx).name("QUANTIDADE_HIDROMETROS").label("Quantidade de hidrômetros");
        
        aQuantidadeHidrometrosAprovados = new DomInteger();
        aQuantidadeHidrometrosAprovados.context(ctx).name("QUANTIDADE_HIDROMETROS_APROVADOS").label("Quantidade de hidrômetros aprovados");
        aQuantidadeHidrometrosAprovados.setDefaultValue("0");
        
        aQuantidadeHidrometrosExecucao = new DomInteger();
        aQuantidadeHidrometrosExecucao.context(ctx).name("QUANTIDADE_HIDROMETROS_EXECUCAO").label("Quantidade de hidrômetros (em execução)");
        aQuantidadeHidrometrosExecucao.setDefaultValue("0");
        
        aQuantidadeHidrometrosPendentes = new DomInteger();
        aQuantidadeHidrometrosPendentes.context(ctx).name("QUANTIDADE_HIDROMETROS_PENDENTES").label("Quantidade de hidrômetros pendentes");
        aQuantidadeHidrometrosPendentes.setDefaultValue("0");
        
        aQuantidadeHidrometrosReprovados = new DomInteger();
        aQuantidadeHidrometrosReprovados.context(ctx).name("QUANTIDADE_HIDROMETROS_REPROVADOS").label("Quantidade de hidrômetros reprovados");
        aQuantidadeHidrometrosReprovados.setDefaultValue("0");
        
        aReservaSequencias = new DomFlag();
        aReservaSequencias.context(ctx).name("RESERVA_SEQUENCIAS").label("Reserva sequencias (nro série)");
        aReservaSequencias.setDefaultValue("S");
        
        aId = new DomId();
        aId.context(ctx).name("ID").label("Id");
        
        aModeloHidrometroId = new DomId();
        aModeloHidrometroId.context(ctx).name("MODELO_HIDROMETRO_ID").label("Modelo de hidrômetro");
        aModeloHidrometroId.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(.)", "q"));
        
        aPlanoExecucaoId = new DomId();
        aPlanoExecucaoId.context(ctx).name("PLANO_EXECUCAO_ID").label("Plano de execução");
        
        aMdlhCodigo = new DomUpper();
        aMdlhCodigo.context(ctx).name("MDLH_CODIGO").label("Código do modelo de hidrômetro");
        aMdlhCodigo.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT MDLH.CODIGO as valor"
                + "     , MDLH.CODIGO || MDLH.DESCRICAO as pesquisar"
                + "     , MDLH.CODIGO || ' #' || MDLH.DESCRICAO as descricao"
                + " from MODELO_HIDROMETRO MDLH"
                + " order by  MDLH.DESCRICAO)", "q"));
        
        aMdlhNome = new DomText();
        aMdlhNome.context(ctx).name("MDLH_NOME").label("Descrição do hidrômetro");
        aMdlhNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT DESCRICAO as valor"
                + " , DESCRICAO as pesquisar"
                + " , DESCRICAO as descricao"
                + " from MODELO_HIDROMETRO MDLH)", "q"));
        aMdlhNome.setAutocompleteLength(2);
        
        aMdlhDiametroNominal = new DomInteger();
        aMdlhDiametroNominal.context(ctx).name("MDLH_DIAMETRO_NOMINAL").label("Diâmetro nominal (mm)");
        aMdlhDiametroNominal.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT DIAMETRO_NOMINAL as valor"
                + " , DIAMETRO_NOMINAL as pesquisar"
                + " , DIAMETRO_NOMINAL as descricao"
                + " from MODELO_HIDROMETRO MDLH)", "q"));
        aMdlhDiametroNominal.setAutocompleteLength(2);
        
        aPlexNome = new DomUpper();
        aPlexNome.context(ctx).name("PLEX_NOME").label("Nome do plano de execução");
        aPlexNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME as valor"
                + " , NOME as pesquisar"
                + " , NOME as descricao"
                + " from PLANO_EXECUCAO PLEX"
                + " where plex.situacao = 'A')", "q"));
        aPlexNome.setAutocompleteLength(2);
        
        aPlexSituacao = new DomOption();
        aPlexSituacao.context(ctx).name("PLEX_SITUACAO").label("Situação do plano").group(true);
        aPlexSituacao.addOption("E", "Em elaboração");
        aPlexSituacao.addOption("A", "Aprovado");
        aPlexSituacao.addOption("D", "Descontinuado");
        aPlexSituacao.setDefaultValue("E");
        
        aVpfsVazaoNominal = new DomDouble();
        aVpfsVazaoNominal.context(ctx).name("VPFS_VAZAO_NOMINAL").label("Vazão nominal (m3/h)");
        aVpfsVazaoNominal.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT VAZAO_NOMINAL as valor"
                + " , VAZAO_NOMINAL as pesquisar"
                + " , VAZAO_NOMINAL as descricao"
                + " from VAZAO_PREFIXO_SERIE VPFS)", "q"));
        aVpfsVazaoNominal.setAutocompleteLength(0);
        
        
        qDataHoraRegistro = new DomDateTime();
        qDataHoraRegistro.context(ctx).name("DATA_HORA_REGISTRO").label("Data e hora do registro");
        
        qPlexNome = new DomUpper();
        qPlexNome.context(ctx).name("PLEX_NOME").label("Nome do plano de execução");
        qPlexNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME as valor"
                + " , NOME as pesquisar"
                + " , NOME as descricao"
                + " from PLANO_EXECUCAO PLEX"
                + " where plex.situacao = 'A')", "q"));
        qPlexNome.setAutocompleteLength(2);
        
        qQuantidadeHidrometros = new DomInteger();
        qQuantidadeHidrometros.context(ctx).name("QUANTIDADE_HIDROMETROS").label("Quantidade de hidrômetros");
        
        qCodigo = new DomText();
        qCodigo.context(ctx).name("CODIGO").label("Código da solicitação");
        
        qDataEnsaio = new DomDate();
        qDataEnsaio.context(ctx).name("DATA_ENSAIO").label("Data planejada para o ensaio");
        
        qMdlhCodigo = new DomUpper();
        qMdlhCodigo.context(ctx).name("MDLH_CODIGO").label("Código do modelo de hidrômetro");
        qMdlhCodigo.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT MDLH.CODIGO as valor"
                + "     , MDLH.CODIGO || MDLH.DESCRICAO as pesquisar"
                + "     , MDLH.CODIGO || ' #' || MDLH.DESCRICAO as descricao"
                + " from MODELO_HIDROMETRO MDLH"
                + " order by  MDLH.DESCRICAO)", "q"));
        
        qSituacao = new DomOption();
        qSituacao.context(ctx).name("SITUACAO").label("Situação da solicitação");
        qSituacao.addOption("P", "Pendente");
        qSituacao.addOption("E", "Em execução");
        qSituacao.addOption("F", "Finalizado");
        
        qMdlhNome = new DomText();
        qMdlhNome.context(ctx).name("MDLH_NOME").label("Descrição do hidrômetro");
        qMdlhNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT DESCRICAO as valor"
                + " , DESCRICAO as pesquisar"
                + " , DESCRICAO as descricao"
                + " from MODELO_HIDROMETRO MDLH)", "q"));
        qMdlhNome.setAutocompleteLength(2);
        
        qVpfsVazaoNominal = new DomDouble();
        qVpfsVazaoNominal.context(ctx).name("VPFS_VAZAO_NOMINAL").label("Vazão nominal (m3/h)");
        qVpfsVazaoNominal.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT VAZAO_NOMINAL as valor"
                + " , VAZAO_NOMINAL as pesquisar"
                + " , VAZAO_NOMINAL as descricao"
                + " from VAZAO_PREFIXO_SERIE VPFS)", "q"));
        qVpfsVazaoNominal.setAutocompleteLength(0);
        
        qSequenciaAutomatica = new DomId();
        qSequenciaAutomatica.context(ctx).name("SEQUENCIA_AUTOMATICA").label("Sequência automática");
        
        qOrigemSolicitacao = new DomOption();
        qOrigemSolicitacao.context(ctx).name("ORIGEM_SOLICITACAO").label("Origem da solicitação");
        qOrigemSolicitacao.addOption("T", "Teste");
        qOrigemSolicitacao.addOption("O", "Ordem de produção");
    }
    
    @Override
    public void initEntityBindings() {
        EntityBinding binding;
        
        binding = new EntityBinding("ZTEST.MODELO_HIDROMETRO", "MDLH", "Z_MDLH_ID", "ZTEST.CAD_MODELO_HIDROMETRO.VIEW");
        binding.addFields(aMdlhCodigo, aMdlhNome, aMdlhDiametroNominal);
        entityBindings.add(binding);
        
        binding = new EntityBinding("ZTEST.PLANO_EXECUCAO", "PLEX", "Z_PLEX_ID", "ZTEST.CAD_PLANO_EXECUCAO.VIEW");
        binding.addFields(aPlexNome, aPlexSituacao);
        entityBindings.add(binding);
    }
    
    @Override
    public String getQueryPkColumn() {
        return "BASE.ID";
    }
    
    @Override
    public void setId(String value) {
        this.aId.setValue(value);
    }
    
    @Override
    public EntSolicitacaoEnsaio getRecord() {
        if (base == null) {
            base = new EntSolicitacaoEnsaio(ctx);
            rec = base;
        }
        return this.base;
    }
    
    @Override
    public String getContextName() {
        return aSequenciaAutomatica.toText();
    }
    
    @Override
    public String getDefaultOrderBy() {
        return "SEQUENCIA_AUTOMATICA, ORIGEM_SOLICITACAO, CODIGO, SITUACAO";
    }
    
    @Override
    public void translateInsertFks(Form form) {
        ModelQuery query;
        
        // MODELO_HIDROMETRO_ID
        try {
            if (form.hasFields("MDLH_CODIGO")) {
                query = createQuery()
                        .select("MDLH.ID")
                        .from("MODELO_HIDROMETRO", "MDLH")
                        .filter("MDLH.CODIGO", form.get("MDLH_CODIGO"))
                        ;
                base.setModeloHidrometroId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
        
        // PLANO_EXECUCAO_ID
        try {
            if (form.hasFields("PLEX_NOME")) {
                query = createQuery()
                        .select("PLEX.ID")
                        .from("PLANO_EXECUCAO", "PLEX")
                        .where("plex.situacao = 'A'")
                        .filter("PLEX.NOME", form.get("PLEX_NOME"))
                        ;
                base.setPlanoExecucaoId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
    }
    
    @Override
    public void translateUpdateFks(Form form) {
        ModelQuery query;
        
        // MODELO_HIDROMETRO_ID
        try {
            if (form.hasFields("MDLH_CODIGO")) {
                query = createQuery()
                        .select("MDLH.ID")
                        .from("MODELO_HIDROMETRO", "MDLH")
                        .filter("MDLH.CODIGO", form.get("MDLH_CODIGO"))
                        ;
                base.setModeloHidrometroId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
        
        // PLANO_EXECUCAO_ID
        try {
            if (form.hasFields("PLEX_NOME")) {
                query = createQuery()
                        .select("PLEX.ID")
                        .from("PLANO_EXECUCAO", "PLEX")
                        .where("plex.situacao = 'A'")
                        .filter("PLEX.NOME", form.get("PLEX_NOME"))
                        ;
                base.setPlanoExecucaoId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
    }
    
    @Override
    public ModuleNavigator getDefaultModuleNavigator() {
        return new ModSolict();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="QUERY">
    public class FQuery extends QueryFeature {
        
        @Override
        public void initForm() {
            addField(qSequenciaAutomatica, "opt");
            addField(qOrigemSolicitacao, "opt");
            addField(qCodigo, "opt");
            addField(qSituacao, "opt");
            addField(qDataHoraRegistro, "opt");
            addField(qDataEnsaio, "opt");
            addField(qMdlhCodigo, "opt");
            addField(qVpfsVazaoNominal, "opt");
            addField(qMdlhNome, "opt");
            addField(qPlexNome, "opt");
            addField(qQuantidadeHidrometros, "opt");
        }
        
        {
            setFeatureName("QUERY");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="LIST">
    public class FList extends ListFeature {
        
        @Override
        public void initForm() {
            addField(aSequenciaAutomatica, "view");
            addField(aOrigemSolicitacao, "view");
            addField(aCodigo, "view");
            addField(aSituacao, "view");
            addField(aDataEnsaio, "view");
            addField(aMdlhCodigo, "view");
            addField(aVpfsVazaoNominal, "view");
            addField(aPlexNome, "view");
            addField(aQuantidadeHidrometros, "view");
        }
        
        {
            setFeatureName("LIST");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="VIEW">
    public class FView extends ViewFeature {
        
        @Override
        public void initForm() {
            addField(aSequenciaAutomatica, "view");
            addField(aOrigemSolicitacao, "view");
            addField(aCodigo, "view");
            addField(aSituacao, "view");
            addField(aDataHoraRegistro, "view");
            addField(aDataEnsaio, "view");
            addField(aMdlhCodigo, "view");
            addField(aVpfsVazaoNominal, "view");
            addField(aMdlhNome, "view");
            addField(aPlexNome, "view");
            addField(aPlexSituacao, "view");
            addField(aQuantidadeHidrometros, "view");
            addField(aQuantidadeHidrometrosAprovados, "view");
            addField(aQuantidadeHidrometrosExecucao, "view");
            addField(aQuantidadeHidrometrosPendentes, "view");
            addField(aQuantidadeHidrometrosReprovados, "view");
            addField(aReservaSequencias, "view");
        }
        
        @Override
        public void posDisplay() {
            {
                CadEnsaioSolicitacao external = new CadEnsaioSolicitacao();
                external.setRuntime(ctx.clone());
                external.init();
                AbstractFeature feature = external.getFeature("LIST");
                external.setParameterIdSolicitacaoEnsaio(aId.getValue());
                external.setDetail(true);
                feature.run();
            }
        }
        
        {
            setFeatureName("VIEW");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="INSERT">
    public class FInsert extends InsertFeature {
        
        @Override
        public void initForm() {
            addField(aOrdemProducao, "opt");
            aDataEnsaio.setOptional(false);
            addField(aDataEnsaio, "rqd");
            aMdlhCodigo.setOptional(false);
            addField(aMdlhCodigo, "rqd");
            aVpfsVazaoNominal.setEditable(false);
            addField(aVpfsVazaoNominal, "view");
            aMdlhNome.setEditable(false);
            addField(aMdlhNome, "view");
            addField(aPlexNome, "opt");
            aPlexSituacao.setEditable(false);
            addField(aPlexSituacao, "view");
            aQuantidadeHidrometros.setOptional(false);
            addField(aQuantidadeHidrometros, "rqd");
            aReservaSequencias.setOptional(false);
            addField(aReservaSequencias, "rqd");
        }
        
        @Override
        public void preDisplay() {
            try {
                contarQtdePlanosAprovados();
            } catch (AdsException ex) {
                throw new ApplicationRuntimeException(ex);
            }
        }
        
        {
            setFeatureName("INSERT");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="UPDATE">
    public class FUpdate extends UpdateFeature {
        
        @Override
        public void initForm() {
            aSequenciaAutomatica.setEditable(false);
            addField(aSequenciaAutomatica, "view");
            aOrigemSolicitacao.setEditable(false);
            addField(aOrigemSolicitacao, "view");
            addField(aOrdemProducao, "opt");
            aSituacao.setEditable(false);
            addField(aSituacao, "view");
            aDataHoraRegistro.setEditable(false);
            addField(aDataHoraRegistro, "view");
            aDataEnsaio.setOptional(false);
            addField(aDataEnsaio, "rqd");
            aMdlhCodigo.setOptional(false);
            addField(aMdlhCodigo, "rqd");
            aVpfsVazaoNominal.setEditable(false);
            addField(aVpfsVazaoNominal, "view");
            aMdlhNome.setEditable(false);
            addField(aMdlhNome, "view");
            aPlexNome.setOptional(false);
            addField(aPlexNome, "rqd");
            aPlexSituacao.setEditable(false);
            addField(aPlexSituacao, "view");
            aQuantidadeHidrometros.setOptional(false);
            addField(aQuantidadeHidrometros, "rqd");
            aQuantidadeHidrometrosAprovados.setEditable(false);
            addField(aQuantidadeHidrometrosAprovados, "view");
            aQuantidadeHidrometrosExecucao.setEditable(false);
            addField(aQuantidadeHidrometrosExecucao, "view");
            aQuantidadeHidrometrosPendentes.setEditable(false);
            addField(aQuantidadeHidrometrosPendentes, "view");
            aQuantidadeHidrometrosReprovados.setEditable(false);
            addField(aQuantidadeHidrometrosReprovados, "view");
            aReservaSequencias.setEditable(false);
            addField(aReservaSequencias, "view");
        }
        
        {
            setFeatureName("UPDATE");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="DELETE">
    public class FDelete extends DeleteFeature {
        
        @Override
        public void initForm() {
            addField(aSequenciaAutomatica, "view");
            addField(aOrigemSolicitacao, "view");
            addField(aCodigo, "view");
            addField(aSituacao, "view");
            addField(aDataEnsaio, "view");
            addField(aMdlhCodigo, "view");
            addField(aVpfsVazaoNominal, "view");
            addField(aPlexNome, "view");
        }
        
        {
            setFeatureName("DELETE");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="MDLH_CODIGO_LOOKUP">
    public class FMdlhCodigoLookup extends LookupFeature {
        
        @Override
        public void initForm() {
            aMdlhCodigo.setEditable(true);
            addField(aMdlhCodigo, "opt");
            aMdlhNome.setEditable(false);
            addField(aMdlhNome, "view");
            aMdlhDiametroNominal.setEditable(false);
            addField(aMdlhDiametroNominal, "view");
            aVpfsVazaoNominal.setEditable(false);
            addField(aVpfsVazaoNominal, "view");
        }
        
        @Override
        public ModelQuery getLookupQuery() {
            return createQuery()
                    .select("MDLH.CODIGO as MDLH_CODIGO")
                    .select("MDLH.DESCRICAO as MDLH_NOME")
                    .select("MDLH.DIAMETRO_NOMINAL as MDLH_DIAMETRO_NOMINAL")
                    .select("VPFS.VAZAO_NOMINAL as VPFS_VAZAO_NOMINAL")
                    .from("MODELO_HIDROMETRO", "MDLH")
                    .leftJoin("VAZAO_PREFIXO_SERIE", "VPFS", "VPFS.ID = MDLH.VAZAO_PREFIXO_SERIE_ID")
                    ;
        }
        
        {
            setFeatureName("MDLH_CODIGO_LOOKUP");
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="PLEX_NOME_LOOKUP">
    public class FPlexNomeLookup extends LookupFeature {
        
        @Override
        public void initForm() {
            aPlexNome.setEditable(true);
            addField(aPlexNome, "opt");
            aPlexSituacao.setEditable(false);
            addField(aPlexSituacao, "view");
        }
        
        @Override
        public ModelQuery getLookupQuery() {
            return createQuery()
                    .select("PLEX.NOME as PLEX_NOME")
                    .select("PLEX.SITUACAO as PLEX_SITUACAO")
                    .from("PLANO_EXECUCAO", "PLEX")
                    .where("plex.situacao = 'A'")
                    ;
        }
        
        {
            setFeatureName("PLEX_NOME_LOOKUP");
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="initFeatures">
    
    @Override
    protected void initFeatures() {
        addFeature(new FQuery());
        addFeature(new FList());
        addFeature(new FView());
        addFeature(new FInsert());
        addFeature(new FUpdate());
        addFeature(new FDelete());
        addFeature(new FMdlhCodigoLookup());
        addFeature(new FPlexNomeLookup());
        super.initFeatures();
    }
    
    @Override
    public String getDefaultFeature() {
        return "QUERY";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Getters and Setters">
    
    public Long getSequenciaAutomatica() {
        return aSequenciaAutomatica.getValue();
    }
    
    public void setSequenciaAutomatica(Long value) {
        this.aSequenciaAutomatica.setValue(value);
    }
    
    public String getOrigemSolicitacao() {
        return aOrigemSolicitacao.getValue();
    }
    
    public void setOrigemSolicitacao(String value) {
        this.aOrigemSolicitacao.setValue(value);
    }
    
    public String getOrdemProducao() {
        return aOrdemProducao.getValue();
    }
    
    public void setOrdemProducao(String value) {
        this.aOrdemProducao.setValue(value);
    }
    
    public String getCodigo() {
        return aCodigo.getValue();
    }
    
    public void setCodigo(String value) {
        this.aCodigo.setValue(value);
    }
    
    public String getSituacao() {
        return aSituacao.getValue();
    }
    
    public void setSituacao(String value) {
        this.aSituacao.setValue(value);
    }
    
    public java.sql.Timestamp getDataHoraRegistro() {
        return aDataHoraRegistro.getValue();
    }
    
    public void setDataHoraRegistro(java.sql.Timestamp value) {
        this.aDataHoraRegistro.setValue(value);
    }
    
    public java.sql.Date getDataEnsaio() {
        return aDataEnsaio.getValue();
    }
    
    public void setDataEnsaio(java.sql.Date value) {
        this.aDataEnsaio.setValue(value);
    }
    
    public Integer getQuantidadeHidrometros() {
        return aQuantidadeHidrometros.getValue();
    }
    
    public void setQuantidadeHidrometros(Integer value) {
        this.aQuantidadeHidrometros.setValue(value);
    }
    
    public Integer getQuantidadeHidrometrosAprovados() {
        return aQuantidadeHidrometrosAprovados.getValue();
    }
    
    public void setQuantidadeHidrometrosAprovados(Integer value) {
        this.aQuantidadeHidrometrosAprovados.setValue(value);
    }
    
    public Integer getQuantidadeHidrometrosExecucao() {
        return aQuantidadeHidrometrosExecucao.getValue();
    }
    
    public void setQuantidadeHidrometrosExecucao(Integer value) {
        this.aQuantidadeHidrometrosExecucao.setValue(value);
    }
    
    public Integer getQuantidadeHidrometrosPendentes() {
        return aQuantidadeHidrometrosPendentes.getValue();
    }
    
    public void setQuantidadeHidrometrosPendentes(Integer value) {
        this.aQuantidadeHidrometrosPendentes.setValue(value);
    }
    
    public Integer getQuantidadeHidrometrosReprovados() {
        return aQuantidadeHidrometrosReprovados.getValue();
    }
    
    public void setQuantidadeHidrometrosReprovados(Integer value) {
        this.aQuantidadeHidrometrosReprovados.setValue(value);
    }
    
    public String getReservaSequencias() {
        return aReservaSequencias.getValue();
    }
    
    public void setReservaSequencias(String value) {
        this.aReservaSequencias.setValue(value);
    }
    
    @Override
    public Long getId() {
        return aId.getValue();
    }
    
    public void setId(Long value) {
        this.aId.setValue(value);
    }
    
    public Long getModeloHidrometroId() {
        return aModeloHidrometroId.getValue();
    }
    
    public void setModeloHidrometroId(Long value) {
        this.aModeloHidrometroId.setValue(value);
    }
    
    public Long getPlanoExecucaoId() {
        return aPlanoExecucaoId.getValue();
    }
    
    public void setPlanoExecucaoId(Long value) {
        this.aPlanoExecucaoId.setValue(value);
    }
    
    public String getMdlhCodigo() {
        return aMdlhCodigo.getValue();
    }
    
    public void setMdlhCodigo(String value) {
        this.aMdlhCodigo.setValue(value);
    }
    
    public String getMdlhNome() {
        return aMdlhNome.getValue();
    }
    
    public void setMdlhNome(String value) {
        this.aMdlhNome.setValue(value);
    }
    
    public Integer getMdlhDiametroNominal() {
        return aMdlhDiametroNominal.getValue();
    }
    
    public void setMdlhDiametroNominal(Integer value) {
        this.aMdlhDiametroNominal.setValue(value);
    }
    
    public String getPlexNome() {
        return aPlexNome.getValue();
    }
    
    public void setPlexNome(String value) {
        this.aPlexNome.setValue(value);
    }
    
    public String getPlexSituacao() {
        return aPlexSituacao.getValue();
    }
    
    public void setPlexSituacao(String value) {
        this.aPlexSituacao.setValue(value);
    }
    
    public Double getVpfsVazaoNominal() {
        return aVpfsVazaoNominal.getValue();
    }
    
    public void setVpfsVazaoNominal(Double value) {
        this.aVpfsVazaoNominal.setValue(value);
    }
    public String getQuerySequenciaAutomatica() {
        return qSequenciaAutomatica.getQueryValue();
    }
    
    public void setQuerySequenciaAutomatica(String value) {
        this.qSequenciaAutomatica.setQueryValue(value);
    }
    public String getQueryOrigemSolicitacao() {
        return qOrigemSolicitacao.getQueryValue();
    }
    
    public void setQueryOrigemSolicitacao(String value) {
        this.qOrigemSolicitacao.setQueryValue(value);
    }
    public String getQueryCodigo() {
        return qCodigo.getQueryValue();
    }
    
    public void setQueryCodigo(String value) {
        this.qCodigo.setQueryValue(value);
    }
    public String getQuerySituacao() {
        return qSituacao.getQueryValue();
    }
    
    public void setQuerySituacao(String value) {
        this.qSituacao.setQueryValue(value);
    }
    public String getQueryDataHoraRegistro() {
        return qDataHoraRegistro.getQueryValue();
    }
    
    public void setQueryDataHoraRegistro(String value) {
        this.qDataHoraRegistro.setQueryValue(value);
    }
    public String getQueryDataEnsaio() {
        return qDataEnsaio.getQueryValue();
    }
    
    public void setQueryDataEnsaio(String value) {
        this.qDataEnsaio.setQueryValue(value);
    }
    public String getQueryMdlhCodigo() {
        return qMdlhCodigo.getQueryValue();
    }
    
    public void setQueryMdlhCodigo(String value) {
        this.qMdlhCodigo.setQueryValue(value);
    }
    public String getQueryVpfsVazaoNominal() {
        return qVpfsVazaoNominal.getQueryValue();
    }
    
    public void setQueryVpfsVazaoNominal(String value) {
        this.qVpfsVazaoNominal.setQueryValue(value);
    }
    public String getQueryMdlhNome() {
        return qMdlhNome.getQueryValue();
    }
    
    public void setQueryMdlhNome(String value) {
        this.qMdlhNome.setQueryValue(value);
    }
    public String getQueryPlexNome() {
        return qPlexNome.getQueryValue();
    }
    
    public void setQueryPlexNome(String value) {
        this.qPlexNome.setQueryValue(value);
    }
    public String getQueryQuantidadeHidrometros() {
        return qQuantidadeHidrometros.getQueryValue();
    }
    
    public void setQueryQuantidadeHidrometros(String value) {
        this.qQuantidadeHidrometros.setQueryValue(value);
    }
    // </editor-fold>
    
    /**
     * Contar qtde planos aprovados.
     */
    private void contarQtdePlanosAprovados() throws AdsException {
        // <user-code id="21756973" parentId="21756813" hashcode="3b2ebe43" length="532">
        // import br.com.telescope.t2.exception.Severity;
        
        int qtde = ctx.computeSqlInteger(
                "select count(*)"
                + " from plano_execucao"
                + " where situacao = 'A'",
                0
                );
        
        if (qtde == 0) {
            ctx.pushError(GLOBAL_NAME, 
                   Severity.ERROR, 
                   "Não encontrado nenhum plano de execução aprovado!"
                   + "\n"
                   + "Atualize o cadastro de planos de execução"
                   + " (Ver: <a href='CadPlanoExecucao?Z_ACTION=LIST'>Lista de planos</a>)"
                   );
        }
        // </user-code>
    }
    
    @Override
    public String getJsServiceFile() {
        return "ui/ztest/cad_solicitacao_ensaio.js";
    }
}
